home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / langs / pcl-src.zoo / sys-proclaim.lsp < prev    next >
Encoding:
Text File  |  1992-07-10  |  68.4 KB  |  1,163 lines
  1.  
  2. (IN-PACKAGE "PCL") 
  3. (PROCLAIM
  4.     '(FTYPE (FUNCTION (FIXNUM T FIXNUM) FIXNUM)
  5.             COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
  6. (PROCLAIM
  7.     '(FTYPE (FUNCTION (T) FIXNUM) ARG-INFO-NUMBER-REQUIRED
  8.             COUNT-NON-NILS CHECKING-LIMIT-FN CACHE-COUNT
  9.             N-N-ACCESSORS-LIMIT-FN ARG-INFO-NKEYS CACHING-LIMIT-FN
  10.             WRAPPER-FIELD ONE-INDEX-LIMIT-FN CPD-COUNT)) 
  11. (PROCLAIM
  12.     '(FTYPE (FUNCTION (FIXNUM) T) NEXT-WRAPPER-FIELD DFUN-ARG-SYMBOL
  13.             SLOT-VECTOR-SYMBOL ALLOCATE-CACHE-VECTOR)) 
  14. (PROCLAIM '(FTYPE (FUNCTION (T) FIELD-TYPE) CACHE-FIELD)) 
  15. (PROCLAIM
  16.     '(FTYPE (FUNCTION (T) LIST) INTERNAL-SLOTD-INITARGS CACHE-OVERFLOW)) 
  17. (PROCLAIM '(FTYPE (FUNCTION (T) REAL-FUNCTION) CACHE-LIMIT-FN)) 
  18. (PROCLAIM '(FTYPE (FUNCTION (T) SIMPLE-VECTOR) CACHE-VECTOR)) 
  19. (PROCLAIM '(FTYPE (FUNCTION (T) SYMBOL) INTERNAL-SLOTD-NAME)) 
  20. (PROCLAIM
  21.     '(FTYPE (FUNCTION (T) (VALUES T T)) MAKE-CLASS-PREDICATE-NAME
  22.             MAKE-KEYWORD LAP-REG GET-METHOD-FROM-IDENTIFIER
  23.             METHOD-FUNCTION-PLIST DEFSTRUCT-FORM)) 
  24. (PROCLAIM
  25.     '(FTYPE (FUNCTION (FIXNUM T) T) MAKE-CAXR MAKE-CDXR
  26.             %CCLOSURE-ENV-NTHCDR)) 
  27. (PROCLAIM
  28.     '(FTYPE (FUNCTION (FIXNUM FIXNUM T) FIXNUM)
  29.             COMPUTE-PRIMARY-CACHE-LOCATION)) 
  30. (PROCLAIM
  31.     '(FTYPE (FUNCTION (FIXNUM) FIXNUM) COMPUTE-LINE-SIZE
  32.             POWER-OF-TWO-CEILING DEFAULT-LIMIT-FN)) 
  33. (PROCLAIM
  34.     '(FTYPE (FUNCTION (T) INDEX) CACHE-NLINES CACHE-MASK
  35.             CACHE-MAX-LOCATION CACHE-SIZE)) 
  36. (PROCLAIM '(FTYPE (FUNCTION (T) (INTEGER 1 512)) CACHE-LINE-SIZE)) 
  37. (PROCLAIM '(FTYPE (FUNCTION (T) (INTEGER 1 256)) CACHE-NKEYS)) 
  38. (PROCLAIM
  39.     '(FTYPE (FUNCTION (T) (OR INDEX NULL)) ARG-INFO-NUMBER-OPTIONAL)) 
  40. (PROCLAIM
  41.     '(FTYPE (FUNCTION (T) (OR FUNCTION NULL))
  42.             INTERNAL-SLOTD-INITFUNCTION)) 
  43. (PROCLAIM
  44.     '(FTYPE (FUNCTION (T T *) *) GET-EFFECTIVE-METHOD-FUNCTION
  45.             SLOT-VALUE-OR-DEFAULT COMPUTE-SECONDARY-DISPATCH-FUNCTION
  46.             MAKE-DOCUMENTED-STANDARD-METHOD-LAMBDA MAKE-ACCESSOR-TABLE
  47.             LOAD-DEFGENERIC MAKE-EFFECTIVE-METHOD-FUNCTION
  48.             MAKE-CHECKING-DFUN MAKE-N-N-ACCESSOR-DFUN
  49.             TYPES-FROM-ARGUMENTS NESTED-WALK-FORM)) 
  50. (PROCLAIM
  51.     '(FTYPE (FUNCTION (T T T) *) ITERATE::EXPAND-INTO-LET
  52.             CONSTANT-VALUE-MISS MAKE-FINAL-N-N-ACCESSOR-DFUN
  53.             MAKE-FINAL-CACHING-DFUN LOAD-LONG-DEFCOMBIN
  54.             ITERATE::RENAME-VARIABLES
  55.             GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
  56.             GET-OPTIMIZED-STD-READER-METHOD-FUNCTION
  57.             MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
  58.             GET-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
  59.             GET-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION SET-SLOT-VALUE
  60.             MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION
  61.             MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION
  62.             SLOT-VALUE-USING-CLASS-DFUN CONVERT-METHODS
  63.             WALKER::WALK-FORM-INTERNAL
  64.             GENERATE-DISCRIMINATION-NET-INTERNAL-DO-COLUMN
  65.             NET-CODE-CONVERTER CACHE-MISS-VALUES
  66.             ITERATE::WALK-GATHERING-BODY SLOT-BOUNDP-USING-CLASS-DFUN
  67.             CHECKING-MISS ACCESSOR-VALUES WALKER::WALK-LET-IF
  68.             MAKE-FINAL-CONSTANT-VALUE-DFUN CACHING-MISS)) 
  69. (PROCLAIM
  70.     '(FTYPE (FUNCTION (T T T T T T T) *)
  71.             ITERATE::ITERATE-TRANSFORM-BODY EXPAND-DEFMETHOD-INTERNAL
  72.             MAKE-LAP-CLOSURE-GENERATOR)) 
  73. (PROCLAIM
  74.     '(FTYPE (FUNCTION (T T T T) *) SIMPLE-SLOTS-GENERATOR-INTERNAL
  75.             ORDER-SPECIALIZERS MAKE-ONE-CLASS-ACCESSOR-DFUN
  76.             GET-ACCESSOR-METHOD-FUNCTION LOAD-SHORT-DEFCOMBIN
  77.             GENERATE-DISCRIMINATION-NET MAKE-FINAL-CHECKING-DFUN
  78.             FINALIZE-LAP-GENERATION EARLY-MAKE-METHOD-LAMBDA
  79.             MAKE-METHOD-LAMBDA-AND-OPTIMIZED-LAMBDA
  80.             NO-METHODS-GENERATOR-INTERNAL
  81.             SETF-SLOT-VALUE-USING-CLASS-DFUN
  82.             MAKE-OPTIMIZED-STANDARD-METHOD-LAMBDA
  83.             MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN ACCESSOR-MISS
  84.             MAKE-ACCESSOR-FROM-SVUC-METHOD-FUNCTION)) 
  85. (PROCLAIM
  86.     '(FTYPE (FUNCTION (T T T T T) *)
  87.             COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL
  88.             MAKE-TWO-CLASS-ACCESSOR-DFUN
  89.             GENERATE-DISCRIMINATION-NET-INTERNAL-DO-METHODS)) 
  90. (PROCLAIM
  91.     '(FTYPE (FUNCTION (T T T *) *) WALKER::WALK-DECLARATIONS
  92.             GET-SECONDARY-DISPATCH-FUNCTION
  93.             MAKE-ONE-INDEX-ACCESSOR-DFUN)) 
  94. (PROCLAIM
  95.     '(FTYPE (FUNCTION (T T T T *) *) ITERATE::RENAME-LET-BINDINGS
  96.             NO-SLOT-ACCESSOR)) 
  97. (PROCLAIM
  98.     '(FTYPE (FUNCTION (T T T T T T) *)
  99.             GENERATE-DISCRIMINATION-NET-INTERNAL
  100.             MAKE-LONG-METHOD-COMBINATION-FUNCTION
  101.             GENERAL-GENERATOR-INTERNAL)) 
  102. (PROCLAIM
  103.     '(FTYPE (FUNCTION (T T T T T T T T) *)
  104.             BOOTSTRAP-INITIALIZE-STRUCTURE-CLASS)) 
  105. (PROCLAIM
  106.     '(FTYPE (FUNCTION (T T T T T T T T T T) *)
  107.             BOOTSTRAP-INITIALIZE-BUILT-IN-CLASS)) 
  108. (PROCLAIM
  109.     '(FTYPE (FUNCTION (T) BOOLEAN) CACHE-VALUEP
  110.             GF-PRECOMPUTE-DFUN-AND-EMF-P GF-INFO-C-A-M-EMF-STD-P
  111.             ARG-INFO-KEY/REST-P)) 
  112. (PROCLAIM
  113.     '(FTYPE (FUNCTION (T) COMPILED-FUNCTION)
  114.             INTERNAL-SLOTD-READER-FUNCTION
  115.             INTERNAL-SLOTD-WRITER-FUNCTION
  116.             INTERNAL-SLOTD-BOUNDP-FUNCTION)) 
  117. (PROCLAIM '(FTYPE (FUNCTION (T STREAM T) T) PRINT-DFUN-INFO)) 
  118. (PROCLAIM
  119.     '(FTYPE (FUNCTION (T T *) T) EMIT-GET-CLASS-SLOT
  120.             EMIT-SET-CLASS-SLOT DEFOPCODE-1 CPL-ERROR
  121.             WALKER::CONVERT-MACRO-TO-LAMBDA
  122.             ENSURE-GENERIC-FUNCTION-USING-CLASS PROCLAIM-FUNCTION
  123.             RECORD-DEFINITION DEFOPERAND-1 PROBE-CACHE
  124.             REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION
  125.             REAL-ENSURE-GF-USING-CLASS--NULL MAP-CACHE
  126.             FIND-CLASS-PREDICATE-FROM-CELL NAMED-OBJECT-PRINT-FUNCTION
  127.             GET-EFFECTIVE-METHOD-FUNCTION1 PLIST-VALUE)) 
  128. (PROCLAIM
  129.     '(FTYPE (FUNCTION (T T T T T T T T *) T) EARLY-MAKE-A-METHOD
  130.             REAL-MAKE-A-METHOD EARLY-ADD-NAMED-METHOD
  131.             REAL-ADD-NAMED-METHOD)) 
  132. (PROCLAIM '(FTYPE (FUNCTION (T T T FIXNUM) T) FILL-CACHE-FROM-CACHE-P)) 
  133. (PROCLAIM
  134.     '(FTYPE (FUNCTION (T T T T T T T T T T T T T T) T)
  135.             ADD-LEXICAL-FUNCTIONS-TO-OPTIMIZED-STANDARD-METHOD-LAMBDA)) 
  136. (PROCLAIM '(FTYPE (FUNCTION (T T T T T T *) T) EMIT-DLAP)) 
  137. (PROCLAIM
  138.     '(FTYPE (FUNCTION (T T T T T T T T T T) T) LOAD-DEFMETHOD-INTERNAL
  139.             LOAD-DEFMETHOD)) 
  140. (PROCLAIM
  141.     '(FTYPE (FUNCTION (T T T T T T T T T T T T T) T)
  142.             BOOTSTRAP-INITIALIZE-STANDARD-CLASS)) 
  143. (PROCLAIM '(FTYPE (FUNCTION (T T T FIXNUM T T *) T) SET-ARG-INFO)) 
  144. (PROCLAIM
  145.     '(FTYPE (FUNCTION (T T T T T T T T T T T T T T T) T)
  146.             ADD-LEXICAL-FUNCTIONS-TO-DOCUMENTED-STANDARD-METHOD-LAMBDA)) 
  147. (PROCLAIM '(FTYPE (FUNCTION (T T FIXNUM) T) COMPUTE-STD-CPL-PHASE-3)) 
  148. (PROCLAIM
  149.     '(FTYPE (FUNCTION (T T T T T T T) T) EXPAND-DEFMETHOD
  150.             MAKE-LAP-CLOSURE-GENERATOR-LAMBDA)) 
  151. (PROCLAIM
  152.     '(FTYPE (FUNCTION (T T T T T) T)
  153.             |CONSTRUCTOR-CODE-GENERATOR PCL SIMPLE-SLOTS|
  154.             LOAD-CONSTRUCTOR MAKE-FINAL-ORDINARY-DFUN-INTERNAL
  155.             BOOTSTRAP-MAKE-SLOT-DEFINITIONS MAKE-LAP-PROG
  156.             EMIT-1-NIL-DLAP DLAP-WRAPPER-MOVES OPTIMIZE-SLOT-VALUE
  157.             OPTIMIZE-SET-SLOT-VALUE OPTIMIZE-SLOT-BOUNDP
  158.             GET-SECONDARY-DISPATCH-FUNCTION2
  159.             |CONSTRUCTOR-CODE-GENERATOR PCL GENERAL|
  160.             WALKER::WALK-TEMPLATE-HANDLE-REPEAT
  161.             MAKE-PARAMETER-REFERENCES
  162.             |CONSTRUCTOR-CODE-GENERATOR PCL NO-METHODS|
  163.             |CONSTRUCTOR-CODE-GENERATOR PCL FALLBACK|
  164.             WALKER::WALK-BINDINGS-1 MAKE-LAP-PROG-INTERNAL
  165.             MAKE-EMF-CACHE BUILD-WITH-ACCESSOR-S-V MAKE-FGEN
  166.             LOAD-FUNCTION-GENERATOR)) 
  167. (PROCLAIM
  168.     '(FTYPE (FUNCTION (T T T) T) SYSTEM::APPLY-DISPLAY-FUN
  169.             PRINT-INTERNAL-SLOTD ONE-INDEX-DFUN-INFO |LAP Opcode NEQ|
  170.             WALKER::WALK-DO* CHECK-OPCODE-ARG WALKER::WALK-IF
  171.             EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
  172.             GET-NEW-FUNCTION-GENERATOR CHECK-INITARGS-1
  173.             SET-FUNCALLABLE-STANDARD-INSTANCE-ACCESS MAKE-SLOT-SYMBOL
  174.             SORT-METHODS ITERATE::OPTIMIZE-GATHERING-FORM
  175.             SORT-APPLICABLE-METHODS
  176.             ITERATE::SIMPLE-EXPAND-GATHERING-FORM
  177.             WRAP-METHOD-GROUP-SPECIFIER-BINDINGS
  178.             EARLY-STORE-METHOD-FUNCTION-P SET-FUNCTION-NAME-1
  179.             EARLY-STORE-METHOD-OPTIMIZED-FUNCTION-P
  180.             EARLY-STORE-CLOSURE-GENERATOR-P PRINT-STD-INSTANCE
  181.             TRACE-FUNCTION-INTERNAL WALKER::WALK-SETQ MAKE-METHOD-SPEC
  182.             OPTIMIZE-SLOT-VALUE-BY-CLASS-P
  183.             ITERATE::OPTIMIZE-ITERATE-FORM SET-STANDARD-INSTANCE-ACCESS
  184.             WALKER::WALK-FLET |LAP Opcode EQ| WALKER::WALK-PROG
  185.             SKIP-FAST-SLOT-ACCESS-P SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P
  186.             CHECK-OPERAND-ARG WALKER::WALK-MULTIPLE-VALUE-BIND
  187.             WALKER::WALK-LABELS WALKER::WALK-TAGBODY-1
  188.             |LAP Opcode FIX=| WALKER::WALK-SYMBOL-MACROLET
  189.             WALKER::WALK-PROG* SET-USER-INSTANCE-ACCESS
  190.             WALKER::WALK-LAMBDA FLUSH-CACHE-TRAP BOOTSTRAP-GET-SLOT
  191.             OBSOLETE-INSTANCE-TRAP UPDATE-STRUCTURE-CLASS
  192.             WALKER::WALK-TAGBODY |SETF PCL METHOD-FUNCTION-GET|
  193.             FIX-SLOT-ACCESSORS |SETF PCL PLIST-VALUE|
  194.             WALKER::WALK-NAMED-LAMBDA SLOW-SET-SLOT-VALUE
  195.             WALKER::WALK-COMPILER-LET WALKER::WALK-LET
  196.             |LAP Operand ISET| WALKER::WALK-MULTIPLE-VALUE-SETQ
  197.             WALKER::RELIST-INTERNAL CAN-OPTIMIZE-ACCESS
  198.             ITERATE::VARIABLE-SAME-P OPTIMIZE-GENERIC-FUNCTION-CALL
  199.             GET-FUNCTION-GENERATOR EMIT-LOCK-COUNT-TEST
  200.             ONE-CLASS-DFUN-INFO WALKER::RECONS WALKER::WALK-LET*
  201.             MAKE-TOP-LEVEL-FORM WALKER::WALK-MACROLET MAP-ALL-ORDERS
  202.             EXPAND-DEFGENERIC SET-CONSTRUCTOR-CODE INVALIDATE-WRAPPER
  203.             EMIT-CHECK-1-CLASS-WRAPPER
  204.             WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
  205.             EARLY-STORE-OPTIMIZED-METHOD-LAMBDA-P CONVERT-TABLE
  206.             MAKE-DFUN-CALL
  207.             EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
  208.             NEW-ARG-INFO-FROM-GENERIC-FUNCTION COMPUTE-PRECEDENCE
  209.             WALKER::WALK-DO ITERATE::RENAME-AND-CAPTURE-VARIABLES
  210.             PRINT-CACHE WALKER::WALK-UNEXPECTED-DECLARE
  211.             VARIABLE-DECLARATION)) 
  212. (PROCLAIM
  213.     '(FTYPE (FUNCTION (T T T T T T) T)
  214.             WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1
  215.             BOOTSTRAP-MAKE-SLOT-DEFINITION MAKE-EARLY-CLASS-DEFINITION
  216.             LOAD-DEFCLASS EMIT-DLAP-INTERNAL EMIT-ADJUST-LOCATION
  217.             EMIT-GREATER-THAN-1-DLAP EMIT-1-T-DLAP
  218.             OPTIMIZE-STD-INSTANCE-ACCESS REAL-LOAD-DEFCLASS
  219.             DO-SHORT-METHOD-COMBINATION BUILD-MAYBE-SAFE-W-O-S-V)) 
  220. (PROCLAIM
  221.     '(FTYPE (FUNCTION (T T T T) T) ADJUST-CACHE EXPAND-CACHE
  222.             MAKE-STD-CLOSURE-GENERATOR-FORM WALKER::WALK-BINDINGS-2
  223.             EXPAND-SYMBOL-MACROLET-INTERNAL
  224.             EMIT-CHECK-1-WRAPPER-IN-CACHE CHECK-INITARGS
  225.             BUILD-W-S-V-FIND-SLOT-INDICES EMIT-CHECK-2-CLASS-WRAPPER
  226.             GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION TWO-CLASS-DFUN-INFO
  227.             EXPAND-DEFCLASS LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
  228.             WALKER::WALK-LET/LET* MAKE-CONSTRUCTOR BOOTSTRAP-SET-SLOT
  229.             WALKER::WALK-TEMPLATE EXPAND-DEFCONSTRUCTOR
  230.             WALKER::WALK-PROG/PROG* EMIT-CHECK-CACHE-LINE
  231.             BOOTSTRAP-ACCESSOR-DEFINITIONS EMIT-CHECK-CACHE-ENTRY
  232.             WALKER::WALK-DO/DO* FILL-CACHE-P)) 
  233. (PROCLAIM
  234.     '(FTYPE (FUNCTION (T T T T *) T) EMIT-FETCH-WRAPPER
  235.             FILL-DFUN-CACHE)) 
  236. (PROCLAIM
  237.     '(FTYPE (FUNCTION (T T T *) T) GET-METHOD FILL-CACHE
  238.             REAL-GET-METHOD EMIT-GET-SLOT EMIT-SET-SLOT
  239.             BUILD-WITH-OPTIMIZED-SLOTS-FORM
  240.             GET-SECONDARY-DISPATCH-FUNCTION1 WALKER::WALK-ARGLIST
  241.             RECORD-UPDATER)) 
  242. (PROCLAIM '(FTYPE (FUNCTION (FIXNUM FIXNUM) FIXNUM) MAKE-INDEX-MASK)) 
  243. (PROCLAIM
  244.     '(FTYPE (FUNCTION NIL *) RENEW-SYS-FILES EMIT-N-N-READERS
  245.             COUNT-ALL-DFUNS EMIT-N-N-WRITERS)) 
  246. (PROCLAIM
  247.     '(FTYPE (FUNCTION NIL T) IN-THE-COMPILER-P RESET-CONSTRUCTORS
  248.             BEFORE-PRECOMPILE-RANDOM-CODE-SEGMENTS BOOTSTRAP-META-BRAID
  249.             DEFAULT-METHOD-ONLY-DFUN-INFO MAKE-ARG-INFO
  250.             |LAP Opcode EXIT-LAP-IN-LISP| DISABLE-CONSTRUCTORS
  251.             RESET-PCL-PACKAGE SHOW-FREE-CACHE-VECTORS
  252.             INITIAL-DISPATCH-DFUN-INFO FLOAT-ZERO
  253.             SHOW-DFUN-CONSTRUCTORS |LAP Opcode BREAK|
  254.             ENABLE-CONSTRUCTORS EARLY-INITIALIZE-SLOT-GFS
  255.             %%ALLOCATE-INSTANCE--CLASS CACHES-TO-ALLOCATE
  256.             ALLOCATE-FUNCALLABLE-INSTANCE-1
  257.             ALLOCATE-FUNCALLABLE-INSTANCE-2 MAKE-CPD
  258.             GET-EFFECTIVE-METHOD-GENSYM DISPATCH-DFUN-INFO
  259.             FIX-DFUNS-NEEDING-UPDATE NO-METHODS-DFUN-INFO
  260.             |LAP Opcode BEEP| MAKE-CACHE BOOTSTRAP-BUILT-IN-CLASSES
  261.             EARLY-INITIALIZE-CLASS-PREDICATES LIST-ALL-DFUNS)) 
  262. (PROCLAIM
  263.     '(FTYPE (FUNCTION (*) *) INVALID-METHOD-ERROR
  264.             METHOD-COMBINATION-ERROR UNTRACE-METHOD
  265.             FINALIZE-ALL-CLASSES LIST-LARGE-CACHES)) 
  266. (PROCLAIM '(FTYPE (FUNCTION (FIXNUM T T) *) COMPUTE-CACHE-PARAMETERS)) 
  267. (PROCLAIM '(FTYPE (FUNCTION (FIXNUM T *) *) FIND-FREE-CACHE-LINE)) 
  268. (PROCLAIM '(FTYPE (FUNCTION (T FIXNUM T) *) EMIT-READER/WRITER)) 
  269. (PROCLAIM
  270.     '(FTYPE (FUNCTION (*) T) |__si::MAKE-TWO-CLASS| TRUE
  271.             |__si::MAKE-ONE-INDEX-DFUN-INFO| WRAPPER-ERROR
  272.             |__si::MAKE-ARG-INFO| |__si::MAKE-STD-INSTANCE|
  273.             |__si::MAKE-CHECKING| |__si::MAKE-CACHING|
  274.             WALKER::UNBOUND-LEXICAL-FUNCTION |__si::MAKE-NO-METHODS|
  275.             |__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION| FALSE
  276.             FIX-EARLY-GENERIC-FUNCTIONS |__si::MAKE-N-N|
  277.             |__si::MAKE-DEFAULT-METHOD-ONLY| FLATTEN-LAP
  278.             |__si::MAKE-CONSTANT-VALUE| STRING-APPEND
  279.             NULL-WRAPPERS-METHOD-FUNCTION |__si::MAKE-INITIAL-DISPATCH|
  280.             |STRUCTURE-OBJECT class constructor|
  281.             CALLED-FIN-WITHOUT-FUNCTION |__si::MAKE-DISPATCH|
  282.             |__si::MAKE-ONE-CLASS| MAKE-PROGN
  283.             |__si::MAKE-ACCESSOR-DFUN-INFO| |__si::MAKE-ONE-INDEX| ZERO
  284.             MAKE-INTERNAL-SLOTD |__si::MAKE-DFUN-INFO|
  285.             |__si::MAKE-CACHE|)) 
  286. (PROCLAIM
  287.     '(FTYPE (FUNCTION (T) *) IN-COMPILER-FORCE-COMPILE
  288.             SLOT-INITFUNCTION-STORAGE-FORM COMPILE-INITFUNCTION
  289.             MAKE-DISPATCH-DFUN EMIT-CONSTANT-VALUE
  290.             COMPUTE-APPLICABLE-METHODS-EMF MAKE-FINAL-DISPATCH-DFUN
  291.             PARSE-METHOD-GROUP-SPECIFIER ANALYZE-LAMBDA-LIST
  292.             PARSE-DEFMETHOD EMIT-ONE-CLASS-READER PCL-DESCRIBE
  293.             COMPUTE-CONSTANT-VECTOR EMIT-ONE-INDEX-READERS
  294.             EMIT-ONE-CLASS-WRITER EMIT-ONE-INDEX-WRITERS
  295.             MAP-CONSTRUCTORS METHOD-FUNCTION-STORAGE-FORM
  296.             COMPILE-FUNCTION EMIT-TWO-CLASS-READER
  297.             DEFAULT-CODE-CONVERTER EARLY-COLLECT-INHERITANCE
  298.             EMIT-TWO-CLASS-WRITER GET-DISPATCH-FUNCTION CCLOSUREP)) 
  299. (PROCLAIM
  300.     '(FTYPE (FUNCTION (FIXNUM T T T) T) GET-WRAPPERS-FROM-CLASSES)) 
  301. (PROCLAIM '(FTYPE (FUNCTION (T FIXNUM *) T) GET-CACHE-FROM-CACHE)) 
  302. (PROCLAIM '(FTYPE (FUNCTION (FIXNUM T T FIXNUM) T) GET-CACHE)) 
  303. (PROCLAIM
  304.     '(FTYPE (FUNCTION (T) T) SIMPLE-EVAL-ACCESS-P UNDEFMETHOD-1
  305.             ALL-STANDARD-ACCESSES-P MAP-ALL-GENERIC-FUNCTIONS
  306.             |LAP Operand WRAPPER-CACHE-NUMBER-VECTOR|
  307.             STRUCTURE-SLOTD-READER-FUNCTION LOOKUP-FGEN
  308.             |LAP Operand OTHER-WRAPPER| TWO-CLASS-ACCESSOR-TYPE
  309.             STORE-FGEN GFS-OF-TYPE DEFAULT-METHOD-ONLY-CACHE
  310.             REALLY-FUNCTION-P METHOD-FUNCTION-METHOD
  311.             FTYPE-DECLARATION-FROM-LAMBDA-LIST EARLY-COLLECT-CPL
  312.             DFUN-INFO-P ARG-INFO-PRECEDENCE GET-WRITER-FUNCTION
  313.             EARLY-METHOD-QUALIFIERS LAP-OPERAND CPD-CLASS
  314.             TWO-CLASS-WRAPPER1 |LAP Opcode JMP| STORE-DEFSTRUCT-FORM
  315.             FLUSH-CACHE-VECTOR-INTERNAL FREE-CACHE CACHE-P
  316.             |LAP Operand LISP-VARIABLE| MAKE-STD-WRITER-METHOD-FUNCTION
  317.             PROCLAIM-CLOSURE EXPAND-LONG-DEFCOMBIN ONE-CLASS-CACHE
  318.             INITIALIZE-INTERNAL-SLOT-BOUNDP-GFS *NORMALIZE-TYPE
  319.             MAKE-FIND-CLASS-CELL STRUCTURE-SLOTD-WRITER-FUNCTION
  320.             FUNCTION-RETURNING-T DEFAULT-TEST-CONVERTER
  321.             INTERNAL-SLOTD-SLOT-DEFINITION ECD-CLASS-NAME GBOUNDP
  322.             CONSTANT-VALUE-CACHE CACHING-DFUN-INFO INTERNAL-SLOTD-P
  323.             MAKE-TYPE-PREDICATE FUNCTION-FTYPE-DECLAIMED-P
  324.             INTERNAL-SLOTD-LOCATION STRUCTURE-TYPE-INCLUDED-TYPE-NAME
  325.             NET-TEST-CONVERTER UPDATE-ALL-C-A-M-GF-INFO
  326.             SYSTEM::NEXT-STACK-FRAME EARLY-GF-NAME
  327.             INITIAL-DISPATCH-CACHE FUNCALLABLE-INSTANCE-P
  328.             TWO-CLASS-CACHE GDEFINITION EARLY-COLLECT-SLOTS
  329.             NO-METHODS-P CACHING-P
  330.             MAKE-STRUCTURE-INSTANCE-READER-METHOD-FUNCTION
  331.             |LAP Operand CVAR| KNOWN-STRUCTURE-TYPE-P
  332.             STRUCTURE-SLOTD-NAME UNTRACE-METHOD-FUNCTION-NAMES
  333.             INDEX-VALUE->INDEX NON-PCL-SHARED-INITIALIZE-METHODS-P
  334.             ONE-CLASS-ACCESSOR-TYPE EXPAND-SHORT-DEFCOMBIN
  335.             CLASS-FROM-TYPE |LAP Opcode LABEL| ONE-CLASS-INDEX
  336.             LIST-DFUN EARLY-CLASS-ORIGINAL-STATIC-SLOT-STORAGE-COPY
  337.             TWO-CLASS-P GET-CACHE-VECTOR
  338.             MAKE-FUNCALLABLE-STANDARD-INSTANCE-WRITER-METHOD-FUNCTION
  339.             DEFAULT-CONSTANT-CONVERTER DEFSTRUCT-FORM-CLASS-NAME
  340.             KEYWORD-SPEC-NAME ARG-INFO-APPLYP
  341.             DEFSTRUCT-FORM-CONSTRUCTOR CONVERT-TO-SYSTEM-TYPE
  342.             CLASS-PREDICATE DFUN-INFO-CACHE LAP-OPCODE
  343.             EARLY-METHOD-FUNCTION MAKE-CLASS-PREDICATE
  344.             USER-INSTANCE-SLOTS USE-CONSTANT-VALUE-DFUN-P
  345.             FUNCTION-PRETTY-ARGLIST ECD-OTHER-INITARGS
  346.             INTERN-FUNCTION-NAME CACHING-CACHE CLASS-STANDARD-P
  347.             EARLY-METHOD-STANDARD-ACCESSOR-P |LAP Operand STD-WRAPPER|
  348.             N-N-P STRUCTURE-OBJECT-P GF-INFO-STATIC-C-A-M-EMF
  349.             PARSE-SPECIALIZERS ITERATE::VARIABLES-FROM-LET
  350.             ALLOCATE-REGISTER CLASS-INSTANCE-TYPE
  351.             UPDATE-GF-SIMPLE-ACCESSOR-TYPE DNET-METHODS-P
  352.             DEFAULT-METHOD-ONLY-P FORCE-CACHE-FLUSHES
  353.             |LAP Operand STD-SLOTS| |LAP Opcode RETURN|
  354.             COMPILER::CAN-USE-PRINT-CIRCLE-P ECD-METACLASS N-N-CACHE
  355.             REDIRECT-EARLY-FUNCTION-INTERNAL LAMBDA-LIST-REQUIRED-ARGS
  356.             INITIALIZE-INTERNAL-SLOT-READER-GFS
  357.             REALLY-COMPILED-FUNCTION-P |LAP Operand BUILT-IN-WRAPPER|
  358.             MAKE-CLASS-EQ-PREDICATE ARG-INFO-METATYPES INSTANCE-TYPE
  359.             CPD-AFTER DEFAULT-CONSTANTP
  360.             INITIALIZE-INTERNAL-SLOT-WRITER-GFS TRACE-METHODS
  361.             TWO-CLASS-INDEX NO-METHODS-CACHE
  362.             EARLY-COLLECT-DEFAULT-INITARGS STRUCTURE-WRAPPER
  363.             MAKE-OPTIMIZED-USER-BOUNDP-METHOD-FUNCTION DISPATCH-P
  364.             UNPARSE-TYPE-LIST N-N-ACCESSOR-TYPE ACCESSOR-DFUN-INFO-P
  365.             CLASS-PRECEDENCE-DESCRIPTION-P ONE-CLASS-WRAPPER0
  366.             METHODS-CONTAIN-EQL-SPECIALIZER-P
  367.             UPDATE-CLASS-CAN-PRECEDE-P TYPE-CLASS ARG-INFO-KEYWORDS
  368.             FGEN-TEST MAKE-STD-READER-METHOD-FUNCTION
  369.             DEFSTRUCT-FORM-CONC-NAME EMIT-MISS FREE-CACHE-VECTOR
  370.             UNENCAPSULATED-FDEFINITION CHECK-WRAPPER-VALIDITY
  371.             MAKE-EQL-PREDICATE UNPARSE-TYPE DLAP-WRAPPERS EARLY-GET-CPL
  372.             FGEN-GENERATOR-LAMBDA STRUCTURE-TYPE-INTERNAL-SLOTDS
  373.             CHECKING-P |LAP Operand ARG| FIND-CYCLE-REASONS CPD-SUPERS
  374.             %CCLOSURE-ENV TWO-CLASS-WRAPPER0 COMPUTE-STD-CPL-PHASE-2
  375.             WALKER::ENV-WALK-FUNCTION GET-BOUNDP-FUNCTION
  376.             |LAP Operand STRUCTURE-WRAPPER| GET-READER-FUNCTION
  377.             |LAP Operand REG| ARG-INFO-LAMBDA-LIST |LAP Operand I1+|
  378.             DEFSTRUCT-FORM-PREDICATE-NAME ARG-INFO-VALID-P
  379.             USER-INSTANCE-P WRAPPER-OF %STD-INSTANCE-WRAPPER
  380.             INITIAL-DISPATCH-P
  381.             MAKE-OPTIMIZED-USER-WRITER-METHOD-FUNCTION
  382.             MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION MAKE-INITIAL-DFUN
  383.             GET-SETF-FUNCTION-NAME USER-INSTANCE-WRAPPER DISPATCH-CACHE
  384.             |LAP Operand USER-WRAPPER| EXTRACT-LAMBDA-LIST
  385.             UPDATE-GFS-OF-CLASS FIND-WRAPPER EXTRACT-SPECIALIZER-NAMES
  386.             DEFAULT-SECONDARY-DISPATCH-FUNCTION FORMAT-CYCLE-REASONS
  387.             FUNCTION-RETURNING-NIL DO-STANDARD-DEFSETFS-FOR-DEFCLASS
  388.             ITERATE::SEQUENCE-ACCESSOR |LAP Operand LISP| EARLY-GF-P
  389.             WALKER::ENV-LEXICAL-VARIABLES ONE-INDEX-DFUN-INFO-CACHE
  390.             MAKE-STD-DOCUMENTED-METHOD-FUNCTION LEGAL-CLASS-NAME-P
  391.             STANDARD-SVUC-METHOD GET-BUILT-IN-CLASS-SYMBOL
  392.             METHOD-PROTOTYPE-FOR-GF |LAP Opcode GO|
  393.             MAKE-STD-BOUNDP-METHOD-FUNCTION WALKER::ENV-DECLARATIONS
  394.             DEALLOCATE-REGISTER WALKER::ENV-WALK-FORM UPDATE-GF-INFO
  395.             ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE CHECKING-CACHE
  396.             INTERN-EQL-SPECIALIZER GMAKUNBOUND DO-STANDARD-DEFSETF-1
  397.             FGEN-GENSYMS INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS
  398.             WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE
  399.             ARG-INFO-P WALKER::ENV-LOCK SPECIALIZER-FROM-TYPE
  400.             GET-CONS-GLOBAL-VARIABLE MAKE-CONSTANT-FUNCTION
  401.             MAKE-CALL-METHODS STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST
  402.             VARIABLE-GLOBALLY-SPECIAL-P ONE-INDEX-P
  403.             STRUCTURE-SVUC-METHOD COMPUTE-APPLICABLE-METHODS-EMF-STD-P
  404.             MAKE-FUNCTION-INLINE |LAP Opcode PRINT| CHECKING-FUNCTION
  405.             ONE-INDEX-CACHE MAKE-DEFCLASS-DIRECT-SLOTS-FROM-DEFSTRUCT
  406.             UPDATE-C-A-M-GF-INFO PROTOTYPE-OF-GENERIC-FUNCTION
  407.             ONE-INDEX-ACCESSOR-TYPE %STD-INSTANCE-SLOTS ONE-INDEX-INDEX
  408.             ECD-SUPERCLASS-NAMES EXTRACT-REQUIRED-PARAMETERS
  409.             CLASS-EQ-TYPE EXTRACT-PARAMETERS UPDATE-SLOTS
  410.             CONSTANT-VALUE-DFUN-INFO
  411.             MAKE-STANDARD-INSTANCE-BOUNDP-METHOD-FUNCTION
  412.             MAKE-STRUCTURE-INSTANCE-WRITER-METHOD-FUNCTION
  413.             GENERIC-CLOBBERS-FUNCTION GF-DFUN-INFO MAKE-INITFUNCTION
  414.             |LAP Operand BUILT-IN-OR-STRUCTURE-WRAPPER|
  415.             |LAP Operand FSC-SLOTS| CANONICAL-SLOT-NAME
  416.             UNPARSE-SPECIALIZERS
  417.             MAKE-FUNCALLABLE-STANDARD-INSTANCE-BOUNDP-METHOD-FUNCTION
  418.             ONE-INDEX-DFUN-INFO-P FGEN-SYSTEM
  419.             MAKE-DOCUMENTED-STD-READER-METHOD-FUNCTION STD-INSTANCE-P
  420.             BUILT-IN-WRAPPER-OF
  421.             NON-PCL-OR-AFTER-SHARED-INITIALIZE-METHODS-P
  422.             SLOT-DEFINITION-DEFSTRUCT-SLOT-DESCRIPTION
  423.             LAP-REG-INITIAL-VALUE-FORM GET-BUILT-IN-WRAPPER-SYMBOL
  424.             WALKER::GET-WALKER-TEMPLATE STRUCTURE-SLOTD-ACCESSOR-SYMBOL
  425.             |LAP Operand CDR|
  426.             MAKE-STANDARD-INSTANCE-WRITER-METHOD-FUNCTION
  427.             EARLY-CLASS-DEFINITION ACCESSOR-DFUN-INFO-CACHE
  428.             MAKE-STANDARD-INSTANCE-READER-METHOD-FUNCTION
  429.             SYSTEM:%STRUCTURE-NAME SLOT-SYMBOL-ERROR
  430.             SYSTEM:%COMPILED-FUNCTION-NAME ONE-INDEX-DFUN-INFO-INDEX
  431.             TYPE-FROM-SPECIALIZER MAP-SPECIALIZERS
  432.             MAKE-DOCUMENTED-STD-WRITER-METHOD-FUNCTION
  433.             NON-PCL-OR-AFTER-INITIALIZE-INSTANCE-METHODS-P
  434.             ACCESSOR-DFUN-INFO-ACCESSOR-TYPE ECD-CANONICAL-SLOTS
  435.             STRUCTURE-SLOT-BOUNDP PROCLAIM-INCOMPATIBLE-SUPERCLASSES
  436.             UN-THE MAKE-WRAPPER |LAP Operand USER-SLOTS|
  437.             |LAP Operand CONSTANT| SLOT-READER-UNDEFINED
  438.             USE-DISPATCH-DFUN-P METHOD-LL->GENERIC-FUNCTION-LL
  439.             LIST-LARGE-CACHE
  440.             MAKE-FUNCALLABLE-STANDARD-INSTANCE-READER-METHOD-FUNCTION
  441.             CONSTANT-VALUE-P GF-INFO-SIMPLE-ACCESSOR-TYPE
  442.             SLOT-BOUNDP-UNDEFINED WRAPPER-FOR-STRUCTURE
  443.             MAKE-STRUCTURE-INSTANCE-BOUNDP-METHOD-FUNCTION
  444.             GF-DFUN-CACHE COPY-CACHE ECD-SOURCE CLASS-OF
  445.             EARLY-CLASS-SLOTS MAKE-NOT-FOR-CACHING-METHOD-FUNCTION
  446.             USE-CACHING-DFUN-P INDEX->INDEX-VALUE
  447.             BUILT-IN-OR-STRUCTURE-WRAPPER-FUN FGEN-GENERATOR
  448.             EARLY-UPDATE-DISCRIMINATOR-CODE COUNT-DFUN ONE-CLASS-P
  449.             NON-PCL-INITIALIZE-INSTANCE-METHODS-P
  450.             MAKE-DOCUMENTED-STD-BOUNDP-METHOD-FUNCTION SETFBOUNDP
  451.             |LAP Operand FSC-WRAPPER|)) 
  452. (PROCLAIM
  453.     '(FTYPE (FUNCTION (T *) *) COMPILE-LAMBDA EXTRACT-DECLARATIONS
  454.             OPCODE GET-FUNCTION OPERAND PARSE-METHOD-OR-SPEC
  455.             MAKE-FINAL-DFUN-INTERNAL PARSE-SPECIALIZED-LAMBDA-LIST
  456.             GET-FUNCTION1 MAP-ALL-CLASSES MAKE-CACHING-DFUN
  457.             MAKE-CONSTANT-VALUE-DFUN WALK-FORM ENSURE-GENERIC-FUNCTION)) 
  458. (PROCLAIM
  459.     '(FTYPE (FUNCTION (T (VECTOR T)) T) ALLOCATE-FUNCALLABLE-INSTANCE)) 
  460. (PROCLAIM '(FTYPE (FUNCTION (T T *) (VALUES T T)) SYMBOL-APPEND)) 
  461. (PROCLAIM
  462.     '(FTYPE (FUNCTION (T *) T) FIND-CLASS ITERATE::FUNCTION-LAMBDA-P
  463.             ITERATE::MAYBE-WARN PRECOMPUTE-EFFECTIVE-METHODS
  464.             LAP-OPERANDS MAKE-SPECIALIZABLE WALKER::RELIST
  465.             LAMBDA-LIST-LEGAL-P MAKE-TYPE-PREDICATE-NAME
  466.             COERCE-TO-CLASS FIND-STRUCTURE-CLASS MAKE-FINAL-DFUN
  467.             GET-METHOD-FUNCTION COMPILE-LAMBDA-DEFERRED
  468.             NO-NEXT-METHOD-TRAP WALKER::RELIST* GET-DFUN-CONSTRUCTOR
  469.             FIND-CLASS-PREDICATE EARLY-METHOD-SPECIALIZERS UPDATE-DFUN
  470.             WALKER::WALKER-ENVIRONMENT-BIND-1 SET-DFUN FIND-CLASS-CELL
  471.             CAPITALIZE-WORDS COMPILE-LAMBDA-UNCOMPILED ENSURE-CLASS)) 
  472. (PROCLAIM
  473.     '(FTYPE (FUNCTION (T T) *) SLOT-VALUE ITERATE::PARSE-DECLARATIONS
  474.             EMIT-WRAPPER-REF *SUBTYPEP SDFUN-FOR-CACHING SAUT-OR-P
  475.             EMIT-CHECKING SAUT-CLASS-EQ-P SAUT-NOT-P COMPUTE-CODE
  476.             EARLY-DFUN FIND-SUPERCLASS-CHAIN COMPUTE-TEST SAUT-EQL-P
  477.             DESTRUCTURE SAUT-CLASS-P SET-FUNCTION-NAME UPDATE-INITS
  478.             CLASS-APPLICABLE-USING-CLASS-P EMIT-CACHING
  479.             EMIT-CACHE-VECTOR-REF GET-NEW-FUNCTION-GENERATOR-INTERNAL
  480.             SPECIALIZER-APPLICABLE-USING-TYPE-P INITIAL-DFUN
  481.             ENSURE-CLASS-VALUES SAUT-AND-P COMPUTE-STD-CPL-PHASE-1
  482.             COMPUTE-APPLICABLE-METHODS-USING-TYPES)) 
  483. (PROCLAIM
  484.     '(FTYPE (FUNCTION (T T) T) REMOVE-METHOD SLOT-BOUNDP SLOT-EXISTS-P
  485.             SLOT-MAKUNBOUND SYSTEM::DISPLAY-ENV
  486.             SYSTEM::DISPLAY-COMPILED-ENV
  487.             |LAP Opcode BUILT-IN-INSTANCE-P|
  488.             LOAD-DEFINE-CONSTRUCTOR-CODE-TYPE |LAP Opcode IZEROP|
  489.             ACCESSOR-MISS-FUNCTION BOOTSTRAP-SLOT-INDEX
  490.             %SET-CCLOSURE-ENV PARSE-QUALIFIER-PATTERN
  491.             METHOD-FUNCTION-GET |LAP Operand I-|
  492.             MAKE-EFFECTIVE-METHOD-FUNCTION1
  493.             |LAP Opcode STRUCTURE-INSTANCE-P|
  494.             SET-METHOD-FUNCTION-METHOD WALKER::ENVIRONMENT-FUNCTION
  495.             SUPERCLASSES-COMPATIBLE-P WALKER::ENVIRONMENT-MACRO
  496.             CLASSES-HAVE-COMMON-SUBCLASS-P *TYPEP
  497.             GENERATE-FAST-CLASS-SLOT-ACCESS-P
  498.             |LAP Opcode FSC-INSTANCE-P| LOAD-DEFOPCODE UPDATE-CLASS
  499.             SLOW-SLOT-VALUE |LAP Opcode MOVE| VARIABLE-CLASS SET-SLOTS
  500.             NET-CONSTANT-CONVERTER MAKE-DFUN-LAMBDA-LIST
  501.             METHODS-CONVERTER ADD-ARG-INFO |LAP Operand IREF|
  502.             |SETF PCL FIND-CLASS| |LAP Operand ISHIFT| PERMUTATION-P
  503.             SLOT-WRITER-UNDEFINED COMPUTE-APPLICABLE-METHODS-FUNCTION
  504.             WALKER::VARIABLE-SYMBOL-MACRO-P USER-INSTANCE-ACCESS
  505.             QUALIFIER-CHECK-RUNTIME |LAP Operand ILOGAND|
  506.             MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE
  507.             MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL
  508.             MAKE-OPTIMIZED-USER-READER-METHOD-FUNCTION
  509.             FIND-SLOT-DEFINITION CANONICALIZE-SLOT-SPECIFICATION
  510.             ITERATE::SIMPLE-EXPAND-ITERATE-FORM FOUND-UNKNOWN-CLASS
  511.             CANONICALIZE-DEFCLASS-OPTION ITERATE::MV-SETQ
  512.             ITERATE::EXTRACT-SPECIAL-BINDINGS N-N-DFUN-INFO
  513.             MEC-ALL-CLASSES-INTERNAL AUGMENT-TYPE WRAPPER-STATE-TRAP
  514.             SET-WRAPPER |LAP Opcode USER-INSTANCE-P|
  515.             SET-USER-INSTANCE-WRAPPER REMOVE-DIRECT-SUBCLASSES
  516.             SET-USER-INSTANCE-SLOTS FDEFINE-CAREFULLY
  517.             |SETF PCL METHOD-FUNCTION-PLIST| MAKE-PLIST
  518.             REMOVE-SLOT-ACCESSORS CLASS-MIGHT-PRECEDE-P
  519.             WALKER::NOTE-DECLARATION DOCTOR-DFUN-FOR-THE-DEBUGGER
  520.             SET-STANDARD-SVUC-METHOD LOAD-DEFOPERAND REDEFINE-MACRO
  521.             DOCUMENTED-FUNCTION-RETURNING-NIL |LAP Operand I+|
  522.             COMPUTE-INITARG-POSITIONS
  523.             COMPUTE-SECONDARY-DISPATCH-FUNCTION1
  524.             NEW-ARG-INFO-FROM-METHOD SET-GET-METHOD-FROM-IDENTIFIER
  525.             TREE-MEMQ-P MEC-ALL-CLASS-LISTS |SETF PCL GDEFINITION|
  526.             REAL-ADD-METHOD MAKE-DLAP-LAMBDA-LIST
  527.             FUNCALLABLE-STANDARD-INSTANCE-ACCESS CPL-INCONSISTENT-ERROR
  528.             REAL-REMOVE-METHOD EARLY-SORT-METHODS COMPUTE-CONSTANTS
  529.             REMTAIL RAISE-METATYPE CLASS-ON-CLASS-PRECEDENCE-LIST-P
  530.             ADD-DIRECT-SUBCLASSES ADD-SLOT-ACCESSORS
  531.             CLASS-CAN-PRECEDE-P REMOVE-ARG-INFO VARIABLE-LEXICAL-P
  532.             |LAP Operand CREF| VARIABLE-SPECIAL-P COMPUTE-STD-CPL
  533.             DO-SATISFIES-DEFTYPE |LAP Operand ILOGXOR|
  534.             WALKER::NOTE-LEXICAL-BINDING
  535.             ACCESSOR-METHODS-SAFE-TO-USE-SLOT-WRAPPER-OPTIMIZATIONS-P
  536.             |LAP Opcode STD-INSTANCE-P| LIST-EQ
  537.             SET-FUNCALLABLE-INSTANCE-FUNCTION VALUE-FOR-CACHING
  538.             MEC-ALL-CLASSES SAUT-NOT-CLASS-P SAUT-NOT-CLASS-EQ-P
  539.             SET-FUNCTION-PRETTY-ARGLIST REDEFINE-FUNCTION
  540.             SET-STRUCTURE-SVUC-METHOD SAUT-NOT-EQL-P NPERMUTATION-P
  541.             DEAL-WITH-ARGUMENTS-OPTION UPDATE-SLOT-VALUE-GF-INFO
  542.             UPDATE-CPL PRINTING-RANDOM-THING-INTERNAL
  543.             CPL-FORWARD-REFERENCED-CLASS-ERROR CHECKING-DFUN-INFO
  544.             SLOW-SLOT-BOUNDP STANDARD-INSTANCE-ACCESS
  545.             UPDATE-STD-OR-STR-METHODS DESTRUCTURE-INTERNAL
  546.             WALKER::WALK-REPEAT-EVAL SYSTEM:%SET-COMPILED-FUNCTION-NAME
  547.             MAKE-DISCRIMINATING-FUNCTION-ARGLIST
  548.             |SETF PCL FIND-CLASS-PREDICATE| MAKE-UNORDERED-METHODS-EMF
  549.             SLOT-VALUES-SAFE-USING-CLASS-P
  550.             DOCUMENTED-FUNCTION-RETURNING-T PROCLAIM-DEFGENERIC
  551.             ADD-METHOD)) 
  552. (PROCLAIM '(FTYPE (FUNCTION NIL FIXNUM) GET-WRAPPER-CACHE-NUMBER)) 
  553. (IN-PACKAGE "PCL")
  554.  
  555. (DOLIST (V '(COMPUTE-INSTANCE-LAYOUT |(WRITER DIRECT-DEFAULT-INITARGS)|
  556.                 ADD-READER-METHOD
  557.                 SHORT-COMBINATION-IDENTITY-WITH-ONE-ARGUMENT
  558.                 SLOT-DEFINITION-INITFUNCTION-SIDE-EFFECT-FREE-P
  559.                 |DEFINITION-SOURCE-MIXIN class predicate|
  560.                 REMOVE-READER-METHOD |(WRITER INTERNAL-SLOTDS)|
  561.                 CLASS-FROM-DEFCLASS-P MAKE-CLOSURE-GENERATOR-FORM
  562.                 EQL-SPECIALIZER-P |(SETF GENERIC-FUNCTION-NAME)|
  563.                 OBJECT-PLIST SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL
  564.                 METHOD-IDENTIFIER
  565.                 MAKE-DOCUMENTED-BOUNDP-METHOD-FUNCTION
  566.                 MAKE-DOCUMENTED-READER-METHOD-FUNCTION
  567.                 MAKE-DOCUMENTED-WRITER-METHOD-FUNCTION SPECIALIZER-TYPE
  568.                 GF-DFUN-STATE |(SETF GENERIC-FUNCTION-METHOD-CLASS)|
  569.                 |(SETF GENERIC-FUNCTION-METHOD-COMBINATION)|
  570.                 CLASS-DEFSTRUCT-CONSTRUCTOR DEPENDENT
  571.                 |(SETF GENERIC-FUNCTION-METHODS)| TRACE-METHOD
  572.                 STORE-CLOSURE-GENERATOR-P |(SETF GF-PRETTY-ARGLIST)|
  573.                 METHOD-OPTIMIZED-FUNCTION SPECIALIZERP
  574.                 EXACT-CLASS-SPECIALIZER-P
  575.                 |STANDARD-OBJECT class predicate|
  576.                 COMPATIBLE-META-CLASS-CHANGE-P
  577.                 |(BOUNDP READER-FUNCTION)| |(BOUNDP PREDICATE-NAME)|
  578.                 |(BOUNDP READERS)| UPDATE-GF-DFUN
  579.                 |(BOUNDP DEFSTRUCT-CONC-NAME)|
  580.                 |(BOUNDP CLASS-PRECEDENCE-LIST)|
  581.                 |(BOUNDP ACCESSOR-FLAGS)|
  582.                 |STANDARD-EFFECTIVE-SLOT-DEFINITION class predicate|
  583.                 CONSTRUCTOR-SUPPLIED-INITARG-NAMES |(BOUNDP LOCATION)|
  584.                 |(BOUNDP DOCUMENTATION)| SPECIALIZER-OBJECT
  585.                 |(BOUNDP CACHED-FUNCTIONS-ALIST)|
  586.                 |(BOUNDP INCOMPATIBLE-SUPERCLASS-LIST)|
  587.                 ACCESSOR-METHOD-SLOT-NAME |(BOUNDP DECLARATIONS)|
  588.                 |(BOUNDP CACHED-IN-GENERIC-FUNCTIONS)|
  589.                 |(BOUNDP SPECIALIZERS)|
  590.                 |STANDARD-DIRECT-SLOT-DEFINITION class predicate|
  591.                 |(BOUNDP IDENTIFIER)| SPECIALIZER-CLASS
  592.                 |(BOUNDP PRETTY-ARGLIST)|
  593.                 |(SETF SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL)|
  594.                 CLASS-EQ-SPECIALIZER-P |(BOUNDP NEEDS-NEXT-METHODS-P)|
  595.                 SLOTS-FETCHER |(SETF SLOT-ACCESSOR-STD-P)|
  596.                 |(BOUNDP INITFUNCTION-SIDE-EFFECT-FREE-P)|
  597.                 |STANDARD-SLOT-DEFINITION class predicate|
  598.                 REMOVE-WRITER-METHOD |(BOUNDP WRITER-FUNCTION)|
  599.                 |(BOUNDP INITFUNCTION)| STRUCTURE-CLASS-P
  600.                 |(BOUNDP WRITERS)| |(BOUNDP INITFORM)|
  601.                 |(BOUNDP FUNCTION-NAME)| UPDATE-CONSTRUCTORS
  602.                 |(BOUNDP SLOT-NAME)| BOUNDP-METHOD-CLASS COMPUTE-LAYOUT
  603.                 |(SETF SLOT-DEFINITION-INITARGS)| |(BOUNDP ALLOCATION)|
  604.                 CACHED-SLOT-LOCATIONS-AND-FETCHERS-FROM-WRAPPERS
  605.                 DOCUMENTATION |(BOUNDP FUNCTION)|
  606.                 |(BOUNDP GENERIC-FUNCTION)|
  607.                 |SLOT-OBJECT class predicate| |(BOUNDP LAMBDA-LIST)|
  608.                 METHOD-PRETTY-ARGLIST |(BOUNDP CAN-PRECEDE-LIST)|
  609.                 |(BOUNDP PROTOTYPE)| CLASS-EQ-SPECIALIZER
  610.                 INFORM-TYPE-SYSTEM-ABOUT-CLASS
  611.                 |PCL-CLASS class predicate| |(BOUNDP DFUN-STATE)|
  612.                 |(BOUNDP FROM-DEFCLASS-P)| |(BOUNDP INTERNAL-SLOTD)|
  613.                 |(BOUNDP METHOD-CLASS)| |(READER SOURCE)|
  614.                 |(BOUNDP METHOD-COMBINATION)|
  615.                 |(BOUNDP OPTIMIZED-FUNCTION)|
  616.                 |(BOUNDP INTERNAL-WRITER-FUNCTION)|
  617.                 |(BOUNDP INTERNAL-READER-FUNCTION)|
  618.                 |(BOUNDP OPTIMIZED-SLOT-INDICES)|
  619.                 |(BOUNDP DIRECT-METHODS)| |(BOUNDP DIRECT-SLOTS)|
  620.                 |(BOUNDP BOUNDP-FUNCTION)|
  621.                 |(BOUNDP DIRECT-SUPERCLASSES)|
  622.                 |(BOUNDP DIRECT-SUBCLASSES)| ADD-CACHED-FUNCTION
  623.                 |(BOUNDP METHODS)| |(BOUNDP OPTIONS)|
  624.                 GET-CACHED-FUNCTION GENERIC-FUNCTION-PRETTY-ARGLIST
  625.                 MAKE-CONSTRUCTOR-CODE-GENERATORS |(WRITER SOURCE)|
  626.                 UPDATE-SLOT-ACCESSOR-FUNCTION
  627.                 |SLOT-DEFINITION class predicate|
  628.                 |(METHOD NO-NEXT-METHOD (STANDARD-GENERIC-FUNCTION STANDARD-METHOD))|
  629.                 MAKE-OPTIMIZED-BOUNDP-METHOD-FUNCTION
  630.                 MAKE-OPTIMIZED-READER-METHOD-FUNCTION
  631.                 MAKE-OPTIMIZED-WRITER-METHOD-FUNCTION
  632.                 |METAOBJECT class predicate| CLASS-PREDICATE-NAME
  633.                 LOAD-CONSTRUCTOR-INTERNAL DESCRIBE-OBJECT-SLOTS
  634.                 STORE-OPTIMIZED-METHOD-LAMBDA-P COPY-INSTANCE-SLOTS
  635.                 CLASSP |STD-CLASS class predicate| LEGAL-QUALIFIERS-P
  636.                 ADD-BOUNDP-METHOD LEGAL-LAMBDA-LIST-P
  637.                 |SETF PCL GENERIC-FUNCTION-NAME|
  638.                 |SETF PCL METHOD-FUNCTION-NAME| LEGAL-DECLARATIONS-P
  639.                 |DEPENDENT-UPDATE-MIXIN class predicate|
  640.                 |(READER READER-FUNCTION)| |(READER PREDICATE-NAME)|
  641.                 |(READER READERS)| |(READER DEFSTRUCT-CONC-NAME)|
  642.                 |(READER CLASS-PRECEDENCE-LIST)|
  643.                 |(READER ACCESSOR-FLAGS)| |(READER LOCATION)|
  644.                 |(READER DOCUMENTATION)| |(SETF CLASS-SLOT-VALUE)|
  645.                 |SETF PCL GF-DFUN-STATE|
  646.                 |(READER CACHED-FUNCTIONS-ALIST)|
  647.                 |(READER INCOMPATIBLE-SUPERCLASS-LIST)|
  648.                 |(READER DECLARATIONS)|
  649.                 |(READER CACHED-IN-GENERIC-FUNCTIONS)|
  650.                 |(READER SPECIALIZERS)| COMPUTE-CLASS-SLOTS
  651.                 |(READER IDENTIFIER)| |(READER PRETTY-ARGLIST)|
  652.                 |(READER NEEDS-NEXT-METHODS-P)|
  653.                 |SETF PCL SLOT-DEFINITION-NAME| |SETF PCL CLASS-NAME|
  654.                 |SETF PCL SLOT-DEFINITION-INTERNAL-SLOTD|
  655.                 |(WRITER READER-FUNCTION)|
  656.                 |(METHOD TRACE-METHOD (STANDARD-METHOD))|
  657.                 |(METHOD TRACE-METHOD (TRACED-METHOD))|
  658.                 |(METHOD READER-METHOD-CLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-DIRECT-SLOT-DEFINITION))|
  659.                 |(METHOD READER-METHOD-CLASS (STANDARD-CLASS STANDARD-DIRECT-SLOT-DEFINITION))|
  660.                 |(METHOD CHANGE-CLASS (T SYMBOL))|
  661.                 |(WRITER PREDICATE-NAME)| |(WRITER READERS)|
  662.                 |(READER INITFUNCTION-SIDE-EFFECT-FREE-P)|
  663.                 |(METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|
  664.                 |(METHOD WRAPPER-FETCHER (STRUCTURE-CLASS))|
  665.                 |(METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
  666.                 |(METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))|
  667.                 |(METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|
  668.                 |(METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|
  669.                 |(METHOD CLASS-SLOT-CELLS (STD-CLASS))|
  670.                 |(METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
  671.                 |(METHOD CLASS-PROTOTYPE (STD-CLASS))|
  672.                 |(METHOD WRAPPER-FETCHER (STANDARD-CLASS))|
  673.                 |(READER WRITER-FUNCTION)| |(READER INITFUNCTION)|
  674.                 |(METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))|
  675.                 INITIALIZE-INTERNAL-SLOT-FUNCTIONS
  676.                 |(WRITER DEFSTRUCT-CONC-NAME)|
  677.                 |SETF PCL SLOT-DEFINITION-TYPE|
  678.                 |(SETF METHOD-FUNCTION-NAME)| |(READER WRITERS)|
  679.                 |(WRITER CLASS-PRECEDENCE-LIST)|
  680.                 |(WRITER ACCESSOR-FLAGS)| |(READER INITFORM)|
  681.                 METHOD-COMBINATION-P
  682.                 |(METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
  683.                 |(METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
  684.                 |(WRITER LOCATION)| |(WRITER DOCUMENTATION)|
  685.                 |STRUCTURE-DIRECT-SLOT-DEFINITION class predicate|
  686.                 |(METHOD ACCESSOR-METHOD-SLOT-DEFINITION (STANDARD-ACCESSOR-METHOD))|
  687.                 |(METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|
  688.                 |(READER FUNCTION-NAME)|
  689.                 |(METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
  690.                 |(METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
  691.                 |(METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
  692.                 |STRUCTURE-EFFECTIVE-SLOT-DEFINITION class predicate|
  693.                 |(METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))|
  694.                 |SETF PCL GENERIC-FUNCTION-METHODS|
  695.                 |SETF PCL GENERIC-FUNCTION-METHOD-COMBINATION|
  696.                 |SETF PCL METHOD-GENERIC-FUNCTION|
  697.                 |SETF PCL METHOD-OPTIMIZED-FUNCTION|
  698.                 |(METHOD ADD-CONSTRUCTOR (SLOT-CLASS CONSTRUCTOR))|
  699.                 |(METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
  700.                 |(METHOD ADD-DIRECT-METHOD (CLASS METHOD))|
  701.                 |(READER SLOT-NAME)| |(WRITER CACHED-FUNCTIONS-ALIST)|
  702.                 |(WRITER INCOMPATIBLE-SUPERCLASS-LIST)|
  703.                 |SETF PCL SLOT-ACCESSOR-STD-P|
  704.                 |(METHOD UPDATE-CONSTRUCTORS (CLASS))|
  705.                 |(METHOD UPDATE-CONSTRUCTORS (SLOT-CLASS))|
  706.                 |(METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))|
  707.                 |(READER ALLOCATION)|
  708.                 |(METHOD (SETF SLOT-DEFINITION-LOCATION) :AFTER (T STANDARD-EFFECTIVE-SLOT-DEFINITION))|
  709.                 |(METHOD (SETF SLOT-DEFINITION-BOUNDP-FUNCTION) :AFTER (T EFFECTIVE-SLOT-DEFINITION))|
  710.                 |(METHOD (SETF SLOT-DEFINITION-WRITER-FUNCTION) :AFTER (T EFFECTIVE-SLOT-DEFINITION))|
  711.                 |(METHOD (SETF SLOT-DEFINITION-READER-FUNCTION) :AFTER (T EFFECTIVE-SLOT-DEFINITION))|
  712.                 |(METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
  713.                 |(METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
  714.                 |SETF PCL CONSTRUCTOR-CODE-TYPE|
  715.                 |(WRITER DECLARATIONS)|
  716.                 |(WRITER CACHED-IN-GENERIC-FUNCTIONS)|
  717.                 |(WRITER SPECIALIZERS)|
  718.                 |(METHOD SPECIALIZER-CLASS (CLASS))|
  719.                 |(METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
  720.                 |(METHOD SPECIALIZER-DIRECT-METHODS (CLASS))|
  721.                 |(METHOD (SETF CLASS-NAME) (T STD-CLASS))|
  722.                 |(WRITER IDENTIFIER)| |(SETF METHOD-GENERIC-FUNCTION)|
  723.                 |(SETF METHOD-OPTIMIZED-FUNCTION)|
  724.                 |(WRITER PRETTY-ARGLIST)| LEGAL-SPECIALIZERS-P
  725.                 |SETF PCL OBJECT-PLIST|
  726.                 |(METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
  727.                 |(METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|
  728.                 |(READER FUNCTION)| |(READER GENERIC-FUNCTION)|
  729.                 |(WRITER NEEDS-NEXT-METHODS-P)| |(READER LAMBDA-LIST)|
  730.                 INITIALIZE-ALLOCATE-STATIC-SLOT-STORAGE-COPY
  731.                 |SLOT-CLASS class predicate|
  732.                 |SETF PCL SLOT-DEFINITION-INITFORM|
  733.                 |(SETF METHOD-CACHED-FUNCTIONS)|
  734.                 |(READER CAN-PRECEDE-LIST)|
  735.                 |SETF PCL GENERIC-FUNCTION-METHOD-CLASS|
  736.                 |(WRITER INITFUNCTION-SIDE-EFFECT-FREE-P)|
  737.                 |(READER PROTOTYPE)| |(WRITER WRITER-FUNCTION)|
  738.                 |(WRITER INITFUNCTION)|
  739.                 |(METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
  740.                 |(METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
  741.                 |(METHOD WRITER-METHOD-CLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-DIRECT-SLOT-DEFINITION))|
  742.                 |(METHOD WRITER-METHOD-CLASS (STANDARD-CLASS STANDARD-DIRECT-SLOT-DEFINITION))|
  743.                 |(METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
  744.                 |(METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS :AFTER (STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
  745.                 |(METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS :AFTER (STANDARD-EFFECTIVE-SLOT-DEFINITION))|
  746.                 |(METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))|
  747.                 |(WRITER WRITERS)| SLOT-ACCESSOR-STD-P
  748.                 CLASS-INTERNAL-SLOTDS |(WRITER INITFORM)|
  749.                 |(METHOD REINITIALIZE-INSTANCE :AFTER (STRUCTURE-CLASS))|
  750.                 |(METHOD INITIALIZE-ALLOCATE-STATIC-SLOT-STORAGE-COPY (STD-CLASS))|
  751.                 |(METHOD REINITIALIZE-INSTANCE :AFTER (STD-CLASS))|
  752.                 |(METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))|
  753.                 |(WRITER FUNCTION-NAME)| |(READER DFUN-STATE)|
  754.                 |(READER FROM-DEFCLASS-P)| |SETF PCL GF-PRETTY-ARGLIST|
  755.                 OPTIMIZE-INSTANCE-ACCESS
  756.                 |SETF PCL SLOT-DEFINITION-LOCATION|
  757.                 |SETF PCL SLOT-DEFINITION-READER-FUNCTION|
  758.                 |SETF PCL SLOT-DEFINITION-WRITER-FUNCTION|
  759.                 |SETF PCL SLOT-DEFINITION-BOUNDP-FUNCTION|
  760.                 |SETF PCL SLOT-DEFINITION-INTERNAL-READER-FUNCTION|
  761.                 |SETF PCL SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION|
  762.                 |SETF PCL SLOT-DEFINITION-ALLOCATION|
  763.                 |SETF PCL SLOT-DEFINITION-INITFUNCTION|
  764.                 |(METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|
  765.                 |(METHOD MAKE-INSTANCE (SYMBOL))| |(WRITER SLOT-NAME)|
  766.                 |(BOUNDP NAME)|
  767.                 |(METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))|
  768.                 |(METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|
  769.                 |(METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|
  770.                 |(READER INTERNAL-SLOTD)|
  771.                 |(METHOD MAKE-DIRECT-SLOTD (STRUCTURE-CLASS))|
  772.                 |(METHOD MAKE-CLASS-PROTOTYPE (STRUCTURE-CLASS))|
  773.                 |(METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
  774.                 |(METHOD MAKE-DIRECT-SLOTD (STD-CLASS))|
  775.                 |(METHOD MAKE-CLASS-PROTOTYPE (STD-CLASS))|
  776.                 |(METHOD MAKE-INSTANCE (SLOT-CLASS))|
  777.                 |(WRITER ALLOCATION)| CACHED-FUNCTIONS
  778.                 |(READER METHOD-CLASS)| |(SETF OBJECT-PLIST)|
  779.                 |(METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
  780.                 |(METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|
  781.                 |(METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
  782.                 |(METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|
  783.                 |(METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))|
  784.                 |(METHOD VALIDATE-SUPERCLASS (CLASS CLASS))|
  785.                 |(METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|
  786.                 |(METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))|
  787.                 |(READER METHOD-COMBINATION)|
  788.                 |(READER OPTIMIZED-FUNCTION)|
  789.                 |(READER INTERNAL-WRITER-FUNCTION)|
  790.                 |(READER INTERNAL-READER-FUNCTION)|
  791.                 METHOD-COMBINATION-OPTIONS
  792.                 |(READER OPTIMIZED-SLOT-INDICES)|
  793.                 |(METHOD COMPUTE-CONSTRUCTOR-CODE (SLOT-CLASS CONSTRUCTOR))|
  794.                 |(METHOD REMOVE-CONSTRUCTOR (SLOT-CLASS CONSTRUCTOR))|
  795.                 |(METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))|
  796.                 |(METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|
  797.                 |(METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
  798.                 |(METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
  799.                 |(READER DIRECT-METHODS)| |(READER DIRECT-SLOTS)|
  800.                 |SETF PCL SLOT-DEFINITION-READERS|
  801.                 |(METHOD COPY-INSTANCE-SLOTS (SLOT-OBJECT SLOT-OBJECT))|
  802.                 |(METHOD SAME-SPECIALIZER-P (CLASS CLASS))|
  803.                 |(METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
  804.                 |(METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))|
  805.                 |(METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))|
  806.                 |(METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))|
  807.                 |(METHOD COMPUTE-SLOTS (STD-CLASS))|
  808.                 |(METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))|
  809.                 |(METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))|
  810.                 |(WRITER FUNCTION)| |(WRITER GENERIC-FUNCTION)|
  811.                 |STRUCTURE-OBJECT class predicate|
  812.                 COMPILE-STRUCTURE-CLASS-INTERNALS
  813.                 |(READER BOUNDP-FUNCTION)| |SETF PCL DOCUMENTATION|
  814.                 |(READER DIRECT-SUPERCLASSES)|
  815.                 |(READER DIRECT-SUBCLASSES)|
  816.                 |(METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))|
  817.                 |(METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|
  818.                 |(SETF GF-VALID-P)| |(WRITER LAMBDA-LIST)|
  819.                 FUNCALLABLE-STANDARD-CLASS-P |(BOUNDP CLASS)|
  820.                 |(METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))|
  821.                 |(METHOD FINALIZE-INHERITANCE (STD-CLASS))|
  822.                 |(METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|
  823.                 |(METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
  824.                 |(METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
  825.                 |(METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
  826.                 |(METHOD SLOT-EXISTS-P-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
  827.                 |(METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
  828.                 |(METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
  829.                 |(METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
  830.                 |(READER METHODS)| |(READER OPTIONS)|
  831.                 |(WRITER CAN-PRECEDE-LIST)|
  832.                 |SETF PCL SLOT-DEFINITION-CLASS|
  833.                 |SETF PCL SLOT-VALUE-USING-CLASS| |(WRITER PROTOTYPE)|
  834.                 |(BOUNDP TYPE)| |(BOUNDP OBJECT)|
  835.                 CLASS-CAN-PRECEDE-LIST
  836.                 |(METHOD SLOTS-FETCHER (STRUCTURE-CLASS))|
  837.                 |(METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
  838.                 |(METHOD SLOTS-FETCHER (STANDARD-CLASS))|
  839.                 SLOT-ACCESSOR-FUNCTION METHOD-OPTIMIZED-METHOD-LAMBDA
  840.                 METHOD-CONSTANT-VALUE |(BOUNDP PLIST)|
  841.                 |SETF PCL CLASS-INCOMPATIBLE-SUPERCLASS-LIST|
  842.                 |SETF PCL SLOT-DEFINITION-WRITERS|
  843.                 |(WRITER DFUN-STATE)| |(WRITER FROM-DEFCLASS-P)|
  844.                 |(BOUNDP SLOTS)|
  845.                 |STRUCTURE-SLOT-DEFINITION class predicate|
  846.                 LEGAL-METHOD-FUNCTION-P |(WRITER INTERNAL-SLOTD)|
  847.                 METHOD-CACHED-FUNCTIONS
  848.                 |(METHOD INSTALL-LAZY-CONSTRUCTOR-INSTALLER (CONSTRUCTOR))|
  849.                 CLASS-DEFSTRUCT-CONC-NAME |(WRITER METHOD-CLASS)|
  850.                 |(METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))|
  851.                 GET-METHOD |(WRITER METHOD-COMBINATION)|
  852.                 |(WRITER OPTIMIZED-FUNCTION)|
  853.                 |(WRITER INTERNAL-WRITER-FUNCTION)|
  854.                 |(WRITER INTERNAL-READER-FUNCTION)|
  855.                 |(WRITER OPTIMIZED-SLOT-INDICES)|
  856.                 |(METHOD METHOD-QUALIFIERS (TRACED-METHOD))|
  857.                 |(METHOD METHOD-SPECIALIZERS (TRACED-METHOD))|
  858.                 |(METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))|
  859.                 |(METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|
  860.                 |(METHOD METHOD-CONSTANT-VALUE (STANDARD-METHOD))|
  861.                 |(METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
  862.                 |(METHOD METHOD-FUNCTION-FOR-CACHING-P (STANDARD-ACCESSOR-METHOD))|
  863.                 |(METHOD METHOD-FUNCTION-FOR-CACHING-P (STANDARD-METHOD))|
  864.                 |(METHOD METHOD-CACHED-FUNCTIONS (STANDARD-METHOD))|
  865.                 |(WRITER DIRECT-METHODS)| |(WRITER DIRECT-SLOTS)|
  866.                 |(WRITER BOUNDP-FUNCTION)|
  867.                 |(WRITER DIRECT-SUPERCLASSES)|
  868.                 |(WRITER DIRECT-SUBCLASSES)|
  869.                 SLOT-DEFINITION-INTERNAL-SLOTD
  870.                 |(METHOD BOUNDP-METHOD-CLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-DIRECT-SLOT-DEFINITION))|
  871.                 |(METHOD BOUNDP-METHOD-CLASS (STANDARD-CLASS STANDARD-DIRECT-SLOT-DEFINITION))|
  872.                 |(WRITER METHODS)| |(WRITER OPTIONS)|
  873.                 SHORT-METHOD-COMBINATION-P GF-ARG-INFO
  874.                 |(METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|
  875.                 |(METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|
  876.                 SEQUENCEP SPECIALIZER-METHOD-TABLE
  877.                 |(METHOD MAYBE-UPDATE-CONSTRUCTORS (GENERIC-FUNCTION METHOD))|
  878.                 METHOD-CLOSURE-GENERATOR REMOVE-CONSTRUCTOR
  879.                 GF-PRETTY-ARGLIST SAME-SPECIALIZER-P CONSTRUCTOR-NAME
  880.                 DO-DEFSTRUCT-FROM-DEFCLASS
  881.                 SLOT-DEFINITION-BOUNDP-FUNCTION
  882.                 SLOT-DEFINITION-WRITER-FUNCTION
  883.                 SLOT-DEFINITION-READER-FUNCTION
  884.                 SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION
  885.                 SLOT-DEFINITION-INTERNAL-READER-FUNCTION
  886.                 CONSTRUCTOR-CODE-TYPE
  887.                 MAKE-CACHED-METHOD-LAMBDA-FROM-STORED-LAMBDA
  888.                 MAKE-CACHED-METHOD-FUNCTION-FROM-STORED-LAMBDA
  889.                 METHOD-OPTIMIZED-SLOT-INDICES ADD-CONSTRUCTOR
  890.                 SLOT-DEFINITION-CLASS GET-CONSTRUCTOR
  891.                 EQL-SPECIALIZER-OBJECT CLASS-CONSTRUCTORS
  892.                 STORE-METHOD-FUNCTION-P
  893.                 STORE-METHOD-OPTIMIZED-FUNCTION-P |(BOUNDP WRAPPER)|
  894.                 SLOTS-TO-INSPECT |(BOUNDP DEFSTRUCT-ACCESSOR-SYMBOL)|
  895.                 SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
  896.                 |(BOUNDP CLASS-EQ-SPECIALIZER)|
  897.                 |(SETF SLOT-DEFINITION-NAME)| ADD-WRITER-METHOD
  898.                 |(BOUNDP ARGUMENT-PRECEDENCE-ORDER)|
  899.                 |(BOUNDP SIDE-EFFECT-INTERNAL-SLOTDS)|
  900.                 |(SETF SLOT-DEFINITION-INTERNAL-SLOTD)|
  901.                 |(BOUNDP ARG-INFO)| CONSTRUCTOR-CLASS
  902.                 |(SETF SLOT-DEFINITION-INITFUNCTION-SIDE-EFFECT-FREE-P)|
  903.                 |(SETF SLOT-DEFINITION-CLASS)|
  904.                 |(SETF SLOT-VALUE-USING-CLASS)|
  905.                 |(BOUNDP DEFAULT-INITARGS)|
  906.                 |(SETF SLOT-DEFINITION-ALLOCATION)|
  907.                 |(SETF SLOT-DEFINITION-BOUNDP-FUNCTION)|
  908.                 |(SETF SLOT-DEFINITION-INITFUNCTION)|
  909.                 |(SETF SLOT-DEFINITION-INTERNAL-READER-FUNCTION)|
  910.                 |(SETF SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION)|
  911.                 |(SETF SLOT-DEFINITION-LOCATION)|
  912.                 |(SETF SLOT-DEFINITION-READER-FUNCTION)|
  913.                 |(SETF SLOT-DEFINITION-WRITER-FUNCTION)|
  914.                 |(BOUNDP DEFSTRUCT-CONSTRUCTOR)|
  915.                 |(SETF SLOT-DEFINITION-READERS)|
  916.                 |(SETF SLOT-DEFINITION-WRITERS)|
  917.                 MAYBE-UPDATE-CONSTRUCTORS |(SETF SLOT-DEFINITION-TYPE)|
  918.                 CONSTRUCTOR-CODE-GENERATORS
  919.                 |(SETF SLOT-DEFINITION-INITFORM)|
  920.                 |EFFECTIVE-SLOT-DEFINITION class predicate|
  921.                 MAKE-CLASS-PROTOTYPE |(BOUNDP VALID-P)|
  922.                 |(BOUNDP INITARGS)| LONG-METHOD-COMBINATION-FUNCTION
  923.                 |BUILT-IN-CLASS class predicate| GENERIC-FUNCTION-P
  924.                 MAKE-OPTIMIZED-METHOD-LAMBDA |(BOUNDP FINALIZED-P)|
  925.                 |(BOUNDP OPTIMIZED-METHOD-LAMBDA)| |(READER NAME)|
  926.                 |(BOUNDP CLOSURE-GENERATOR)| |(READER CLASS)|
  927.                 |(BOUNDP DIRECT-DEFAULT-INITARGS)| LEGAL-SLOT-NAME-P
  928.                 |(READER TYPE)| |(READER OBJECT)|
  929.                 |(METHOD DO-DEFSTRUCT-FROM-DEFCLASS (STRUCTURE-CLASS T T T T T))|
  930.                 CLASS-WRAPPER |(READER PLIST)| GF-VALID-P
  931.                 |(METHOD NO-APPLICABLE-METHOD (T))| |(READER SLOTS)|
  932.                 |(BOUNDP INTERNAL-SLOTDS)| |(WRITER NAME)|
  933.                 DEFINITION-SOURCE DEFAULT-INITARGS |(WRITER CLASS)|
  934.                 CLASS-SLOT-VALUE |(WRITER TYPE)| |(WRITER OBJECT)|
  935.                 |(WRITER PLIST)| |(WRITER SLOTS)|
  936.                 FORWARD-REFERENCED-CLASS-P
  937.                 CLASS-SIDE-EFFECT-INTERNAL-SLOTDS
  938.                 |SPECIALIZER-WITH-OBJECT class predicate|
  939.                 LEGAL-QUALIFIER-P METHOD-P
  940.                 |PLIST-MIXIN class predicate| MAKE-DIRECT-SLOTD
  941.                 CLASS-SLOT-CELLS COMPUTE-CONSTRUCTOR-CODE
  942.                 |(METHOD LOAD-CONSTRUCTOR-INTERNAL (SLOT-CLASS T T T))|
  943.                 |(METHOD SHARED-INITIALIZE :AFTER (STANDARD-GENERIC-FUNCTION T))|
  944.                 |(METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
  945.                 |(METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
  946.                 |(METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
  947.                 |(METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))|
  948.                 |(METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))|
  949.                 |(METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
  950.                 |(METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
  951.                 |(METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
  952.                 |(METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
  953.                 |(METHOD READER-METHOD-CLASS (T T))|
  954.                 |(METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
  955.                 |(METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
  956.                 |(METHOD SHARED-INITIALIZE :BEFORE (STD-CLASS T))|
  957.                 |(METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
  958.                 |(METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
  959.                 |(METHOD SHARED-INITIALIZE :BEFORE (DOCUMENTATION-MIXIN T))|
  960.                 |(METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
  961.                 |(METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
  962.                 STANDARD-ACCESSOR-METHOD-P |(SETF CLASS-NAME)|
  963.                 |(METHOD CACHED-SLOT-LOCATIONS-AND-FETCHERS-FROM-WRAPPERS (STANDARD-METHOD T))|
  964.                 |(METHOD UPDATE-GF-DFUN (STD-CLASS T))|
  965.                 |(METHOD ADD-CACHED-FUNCTION (STANDARD-METHOD T T))|
  966.                 |(METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
  967.                 |(METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
  968.                 |(METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
  969.                 |(METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
  970.                 |(METHOD UPDATE-SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T T))|
  971.                 |(METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|
  972.                 STANDARD-GENERIC-FUNCTION-P STANDARD-METHOD-P
  973.                 STANDARD-READER-METHOD-P |(METHOD DOCUMENTATION (T))|
  974.                 |(READER WRAPPER)|
  975.                 |(METHOD (SETF DOCUMENTATION) (T T))|
  976.                 |(METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
  977.                 |(METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
  978.                 |SETF PCL GF-VALID-P|
  979.                 |(READER DEFSTRUCT-ACCESSOR-SYMBOL)|
  980.                 |(METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
  981.                 |(METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
  982.                 |(METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
  983.                 |(METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
  984.                 |(METHOD DEFAULT-INITARGS (SLOT-CLASS T T))|
  985.                 |(READER CLASS-EQ-SPECIALIZER)|
  986.                 COMPUTE-DEFAULT-INITARGS
  987.                 COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS
  988.                 |(METHOD LEGAL-LAMBDA-LIST-P (STANDARD-GENERIC-FUNCTION T))|
  989.                 |(METHOD LEGAL-DECLARATIONS-P (STANDARD-GENERIC-FUNCTION T))|
  990.                 |(METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
  991.                 |(METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
  992.                 |(METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|
  993.                 |(METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|
  994.                 |(METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
  995.                 |(METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|
  996.                 |(METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
  997.                 |(METHOD LEGAL-DOCUMENTATION-P (DOCUMENTATION-MIXIN T))|
  998.                 |(SETF CLASS-INCOMPATIBLE-SUPERCLASS-LIST)|
  999.                 |SETF PCL CLASS-SLOT-VALUE|
  1000.                 |(READER ARGUMENT-PRECEDENCE-ORDER)|
  1001.                 |(READER SIDE-EFFECT-INTERNAL-SLOTDS)|
  1002.                 |(METHOD PRINT-OBJECT (CONSTRUCTOR T))|
  1003.                 |(METHOD PRINT-OBJECT (METHOD-COMBINATION T))|
  1004.                 |(METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
  1005.                 |(METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
  1006.                 |(METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
  1007.                 |(METHOD PRINT-OBJECT (STANDARD-METHOD T))|
  1008.                 |(METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
  1009.                 |(METHOD PRINT-OBJECT (CLASS T))|
  1010.                 |(METHOD PRINT-OBJECT (T T))|
  1011.                 |(METHOD WRITER-METHOD-CLASS (T T))|
  1012.                 |(METHOD TRACE-METHOD (CONS))| |(READER ARG-INFO)|
  1013.                 METHOD-COMBINATION-TYPE
  1014.                 |SETF PCL SLOT-DEFINITION-INITFUNCTION-SIDE-EFFECT-FREE-P|
  1015.                 |(READER DEFAULT-INITARGS)|
  1016.                 CLASS-CACHED-IN-GENERIC-FUNCTIONS
  1017.                 |(READER DEFSTRUCT-CONSTRUCTOR)|
  1018.                 |(METHOD MAKE-CACHED-METHOD-LAMBDA-FROM-STORED-LAMBDA (STANDARD-METHOD T))|
  1019.                 |(METHOD MAKE-CONSTRUCTOR-CODE-GENERATORS (SLOT-CLASS T T T T))|
  1020.                 |(METHOD MAKE-CLOSURE-GENERATOR-FORM (STANDARD-GENERIC-FUNCTION STANDARD-METHOD T T))|
  1021.                 |(METHOD MAKE-OPTIMIZED-METHOD-LAMBDA (STANDARD-GENERIC-FUNCTION STANDARD-METHOD T T))|
  1022.                 |(METHOD MAKE-METHOD-LAMBDA (STANDARD-GENERIC-FUNCTION STANDARD-METHOD T T))|
  1023.                 |(METHOD MAKE-CACHED-METHOD-FUNCTION-FROM-STORED-LAMBDA (STANDARD-METHOD T))|
  1024.                 |(METHOD MAKE-OPTIMIZED-BOUNDP-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T T T))|
  1025.                 |(METHOD MAKE-OPTIMIZED-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T T T))|
  1026.                 |(METHOD MAKE-OPTIMIZED-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T T T))|
  1027.                 |(METHOD MAKE-OPTIMIZED-BOUNDP-METHOD-FUNCTION (STRUCTURE-CLASS T T T))|
  1028.                 |(METHOD MAKE-OPTIMIZED-WRITER-METHOD-FUNCTION (STRUCTURE-CLASS T T T))|
  1029.                 |(METHOD MAKE-OPTIMIZED-READER-METHOD-FUNCTION (STRUCTURE-CLASS T T T))|
  1030.                 |(METHOD MAKE-OPTIMIZED-BOUNDP-METHOD-FUNCTION (STANDARD-CLASS T T T))|
  1031.                 |(METHOD MAKE-OPTIMIZED-WRITER-METHOD-FUNCTION (STANDARD-CLASS T T T))|
  1032.                 |(METHOD MAKE-OPTIMIZED-READER-METHOD-FUNCTION (STANDARD-CLASS T T T))|
  1033.                 |(METHOD MAKE-OPTIMIZED-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T T T))|
  1034.                 |(METHOD MAKE-OPTIMIZED-WRITER-METHOD-FUNCTION (SLOT-CLASS T T T))|
  1035.                 |(METHOD MAKE-OPTIMIZED-READER-METHOD-FUNCTION (SLOT-CLASS T T T))|
  1036.                 |(METHOD MAKE-DOCUMENTED-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T T T))|
  1037.                 |(METHOD MAKE-DOCUMENTED-WRITER-METHOD-FUNCTION (SLOT-CLASS T T T))|
  1038.                 |(METHOD MAKE-DOCUMENTED-READER-METHOD-FUNCTION (SLOT-CLASS T T T))|
  1039.                 |(WRITER WRAPPER)| STANDARD-CLASS-P
  1040.                 |(SETF CONSTRUCTOR-CODE-TYPE)| LEGAL-SPECIALIZER-P
  1041.                 |(WRITER DEFSTRUCT-ACCESSOR-SYMBOL)|
  1042.                 |(METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
  1043.                 |(METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
  1044.                 |(METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION STANDARD-METHOD-COMBINATION T))|
  1045.                 |(METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
  1046.                 |(METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
  1047.                 |(METHOD REMOVE-NAMED-METHOD (T T))|
  1048.                 |(METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
  1049.                 |(METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (STRUCTURE-CLASS T T))|
  1050.                 |(METHOD COMPILE-STRUCTURE-CLASS-INTERNALS (STRUCTURE-CLASS T T T T))|
  1051.                 |(METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
  1052.                 |(METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
  1053.                 |(METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
  1054.                 |(METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
  1055.                 |(METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
  1056.                 |(METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
  1057.                 |(METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (FUNCALLABLE-STANDARD-CLASS T T))|
  1058.                 |(METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (STANDARD-CLASS T T))|
  1059.                 |(METHOD COMPUTE-LAYOUT (STD-CLASS T T))|
  1060.                 |(METHOD COMPUTE-CLASS-SLOTS (STD-CLASS T))|
  1061.                 |(METHOD COMPUTE-INSTANCE-LAYOUT (STD-CLASS T))|
  1062.                 |(METHOD COMPUTE-STORAGE-INFO (STD-CLASS T))|
  1063.                 COMPUTE-STORAGE-INFO |(READER VALID-P)|
  1064.                 |DIRECT-SLOT-DEFINITION class predicate|
  1065.                 METHOD-FUNCTION-NAME |(READER INITARGS)|
  1066.                 |(WRITER CLASS-EQ-SPECIALIZER)|
  1067.                 |(METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
  1068.                 STANDARD-BOUNDP-METHOD-P METHOD-FUNCTION-FOR-CACHING
  1069.                 |(METHOD STORE-OPTIMIZED-METHOD-LAMBDA-P (STANDARD-GENERIC-FUNCTION STANDARD-METHOD T))|
  1070.                 |(METHOD STORE-CLOSURE-GENERATOR-P (STANDARD-GENERIC-FUNCTION STANDARD-METHOD T))|
  1071.                 |(METHOD STORE-METHOD-OPTIMIZED-FUNCTION-P (STANDARD-GENERIC-FUNCTION STANDARD-METHOD T))|
  1072.                 |(METHOD STORE-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION STANDARD-METHOD T))|
  1073.                 |(METHOD SLOT-UNBOUND :AROUND (CLASS T T))|
  1074.                 |(METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
  1075.                 |(METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
  1076.                 |(METHOD SLOT-MISSING (T T T T))|
  1077.                 |(METHOD SLOT-UNBOUND (T T T))| |(READER FINALIZED-P)|
  1078.                 |(SETF DOCUMENTATION)|
  1079.                 |SETF PCL METHOD-CACHED-FUNCTIONS|
  1080.                 RAW-INSTANCE-ALLOCATOR
  1081.                 |(WRITER ARGUMENT-PRECEDENCE-ORDER)|
  1082.                 INSTALL-LAZY-CONSTRUCTOR-INSTALLER
  1083.                 |(WRITER SIDE-EFFECT-INTERNAL-SLOTDS)|
  1084.                 |(METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
  1085.                 METHOD-FUNCTION-FOR-CACHING-P
  1086.                 |SETF PCL SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL|
  1087.                 |(WRITER ARG-INFO)| |(READER OPTIMIZED-METHOD-LAMBDA)|
  1088.                 COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO
  1089.                 STANDARD-WRITER-METHOD-P
  1090.                 CLASS-INCOMPATIBLE-SUPERCLASS-LIST
  1091.                 |(WRITER DEFAULT-INITARGS)|
  1092.                 |(WRITER DEFSTRUCT-CONSTRUCTOR)|
  1093.                 |(METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
  1094.                 |(METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
  1095.                 WRAPPER-FETCHER |(METHOD DESCRIBE-OBJECT (CLASS T))|
  1096.                 |(METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
  1097.                 |(METHOD DESCRIBE-OBJECT-SLOTS (SLOT-OBJECT T))|
  1098.                 |(METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|
  1099.                 |(METHOD DESCRIBE-OBJECT (T T))|
  1100.                 |(METHOD DESCRIBE-OBJECT (CONSTRUCTOR T))|
  1101.                 |SETF PCL SLOT-DEFINITION-INITARGS|
  1102.                 |(READER CLOSURE-GENERATOR)| REMOVE-BOUNDP-METHOD
  1103.                 |(METHOD GET-CONSTRUCTOR (SLOT-CLASS T))|
  1104.                 |(METHOD OPTIMIZE-INSTANCE-ACCESS (STANDARD-GENERIC-FUNCTION STANDARD-METHOD STRUCTURE-CLASS T T T T T))|
  1105.                 |(METHOD OPTIMIZE-INSTANCE-ACCESS (STANDARD-GENERIC-FUNCTION STANDARD-METHOD T T T T T T))|
  1106.                 |(METHOD METHOD-FUNCTION-FOR-CACHING (STANDARD-ACCESSOR-METHOD T))|
  1107.                 |(METHOD GET-CACHED-FUNCTION (STANDARD-METHOD T))|
  1108.                 |(METHOD METHOD-FUNCTION-FOR-CACHING (STANDARD-METHOD T))|
  1109.                 |(WRITER VALID-P)| |(WRITER INITARGS)|
  1110.                 |(METHOD BOUNDP-METHOD-CLASS (SLOT-CLASS T))|
  1111.                 |(METHOD BOUNDP-METHOD-CLASS (T T))|
  1112.                 |(WRITER FINALIZED-P)|
  1113.                 |(READER DIRECT-DEFAULT-INITARGS)| |(BOUNDP SOURCE)|
  1114.                 |DOCUMENTATION-MIXIN class predicate|
  1115.                 |(WRITER OPTIMIZED-METHOD-LAMBDA)|
  1116.                 |(SETF GF-DFUN-STATE)| |(READER INTERNAL-SLOTDS)|
  1117.                 SHORT-COMBINATION-OPERATOR METHOD-NEEDS-NEXT-METHODS-P
  1118.                 |(WRITER CLOSURE-GENERATOR)| REMOVE-NAMED-METHOD
  1119.                 |(METHOD ENSURE-CLASS-USING-CLASS (T NULL))|
  1120.                 LEGAL-DOCUMENTATION-P CLASS-DIRECT-SUPERCLASSES
  1121.                 CLASS-DIRECT-SUBCLASSES CLASS-DIRECT-DEFAULT-INITARGS
  1122.                 SLOT-DEFINITION-READERS SLOT-VALUE-USING-CLASS
  1123.                 DESCRIBE-OBJECT COMPUTE-APPLICABLE-METHODS CLASS-NAME
  1124.                 CLASS-PROTOTYPE READER-METHOD-CLASS REMOVE-METHOD
  1125.                 SLOT-DEFINITION-INITFORM
  1126.                 UPDATE-INSTANCE-FOR-REDEFINED-CLASS
  1127.                 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS CHANGE-CLASS
  1128.                 METHOD-FUNCTION DIRECT-SLOT-DEFINITION-CLASS
  1129.                 MAKE-METHOD-LAMBDA EFFECTIVE-SLOT-DEFINITION-CLASS
  1130.                 CLASS-SLOTS COMPUTE-SLOTS SLOT-DEFINITION-NAME
  1131.                 FINALIZE-INHERITANCE
  1132.                 GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER
  1133.                 GENERIC-FUNCTION-LAMBDA-LIST NO-NEXT-METHOD
  1134.                 CLASS-DIRECT-SLOTS CLASS-DEFAULT-INITARGS
  1135.                 COMPUTE-DISCRIMINATING-FUNCTION CLASS-FINALIZED-P
  1136.                 GENERIC-FUNCTION-NAME REMOVE-DEPENDENT
  1137.                 COMPUTE-CLASS-PRECEDENCE-LIST ADD-DEPENDENT
  1138.                 SLOT-BOUNDP-USING-CLASS ACCESSOR-METHOD-SLOT-DEFINITION
  1139.                 SHARED-INITIALIZE ADD-DIRECT-METHOD
  1140.                 SLOT-DEFINITION-LOCATION SLOT-DEFINITION-INITFUNCTION
  1141.                 SLOT-DEFINITION-ALLOCATION ADD-METHOD
  1142.                 GENERIC-FUNCTION-METHOD-CLASS METHOD-SPECIALIZERS
  1143.                 SLOT-DEFINITION-INITARGS WRITER-METHOD-CLASS
  1144.                 ADD-DIRECT-SUBCLASS SPECIALIZER-DIRECT-METHODS
  1145.                 GENERIC-FUNCTION-METHOD-COMBINATION ALLOCATE-INSTANCE
  1146.                 COMPUTE-EFFECTIVE-METHOD SLOT-DEFINITION-TYPE
  1147.                 SLOT-UNBOUND INITIALIZE-INSTANCE FUNCTION-KEYWORDS
  1148.                 SLOT-EXISTS-P-USING-CLASS REINITIALIZE-INSTANCE
  1149.                 VALIDATE-SUPERCLASS GENERIC-FUNCTION-METHODS
  1150.                 REMOVE-DIRECT-METHOD METHOD-LAMBDA-LIST MAKE-INSTANCE
  1151.                 GENERIC-FUNCTION-DECLARATIONS
  1152.                 COMPUTE-EFFECTIVE-SLOT-DEFINITION PRINT-OBJECT
  1153.                 METHOD-QUALIFIERS METHOD-GENERIC-FUNCTION
  1154.                 REMOVE-DIRECT-SUBCLASS MAKE-INSTANCES-OBSOLETE
  1155.                 SLOT-MAKUNBOUND-USING-CLASS
  1156.                 ENSURE-GENERIC-FUNCTION-USING-CLASS SLOT-MISSING
  1157.                 MAP-DEPENDENTS FIND-METHOD-COMBINATION
  1158.                 ENSURE-CLASS-USING-CLASS NO-APPLICABLE-METHOD
  1159.                 SLOT-DEFINITION-WRITERS
  1160.                 COMPUTE-APPLICABLE-METHODS-USING-CLASSES
  1161.                 CLASS-PRECEDENCE-LIST))
  1162.   (SETF (GET V 'COMPILER::PROCLAIMED-CLOSURE) T)) 
  1163.